; PLAY-AY.SCE  OVerLanders 24/5/2000
; v0.5
; 
;  Concu avec dams en #3e8 / #C0 / M#6600
; 
;    Pour placer manuellement ses tampons de decompression, definir OFTAB0 etc,
; mettre  les bons JUMP en V0 etc et enlever CALL ATTRIBU
; 
; C'est quand on vit seul qu'on a le plus besoin d'un lit a deux places.
; 
	org &4000
nolist
; &0740
WANTLOOP        equ 1           ; 0 = ne boucle pas (routine + rapide)
DECRUBUF        equ &7000       ; doit valoir x000 ou x800 (cf ATTRIBU)
MUSIC_ADDRESS   equ &4800       ; Adresse fichier compacte
BUFFER_ADDRESS  equ &56

	jp initialize_player
; ------------------------
play_music		;	jp play_music
; ------------------------
P1	equ GETREG
P2	equ PLAYREG

; ------------------------
initialize_player
; ------------------------

; ------------------------
; Get the music duration
; ------------------------

        ld HL,(MUSIC_ADDRESS)
        ld (MESURE+1),HL

; ------------------------
; ATTRIBU
; 
; On reparti les tampons de decompressions. Ceux de &400 de long se placent
;      en &?000 ou &?800 pour faciliter le modulo, et la routine intercale
; ceux de &100 dans les trous (pile poil).
; 
; On place d'abord ceux de &400
; ------------------------
        ld HL,OFBUF0
        ld D,DECRUBUF/&100
        exx
        ld HL,(ADRTEMP)
        INC HL
        INC HL		; Flag Decomp400 ou Decomp100
        push HL
        ld DE,3
        ld A,(NBR_REG)
        ld B,A		; B=cpt loop, C = nbr de buffer400
        ld C,0
ATT_LP
        ld A,(HL)
        cp 1
        JR Z,ATT_BUF1
        exx
        ld (HL),D
        INC HL
        ld (HL),4
        dec HL
        ld A,D
        ADD A,8
        ld D,A
        exx
        INC C
ATT_BUF1
        exx
        INC HL
        INC HL
        exx
        ADD HL,DE
        DJNZ ATT_LP
; 
; Maintenant on va placer les buffer100
; 
        ld HL,OFBUF0
        ld D,DECRUBUF/&100
        ld B,3		; Pour intercaler 4 buffer100
        exx
        pop HL
        push HL
        ld DE,3
        ld A,(NBR_REG)
        ld B,A
ATT_LP2
        ld A,(HL)
        cp 4		; On l'a deja traite
        JR Z,ATT_BUF4
        exx
        ld A,B
        INC A
        AND 3
        ld B,A
        JR NZ,ATT_OK	; On est pas sur une adr congrue a &400
        ld A,C
        OR A
        JR Z,ATT_OK	; On a passe tout les buffer &100
        dec C
        ld A,D		; Sinon on saute buffer &400
        ADD A,4
        ld D,A
ATT_OK
        ld (HL),D
        INC HL
        ld (HL),1
        dec HL
        INC D
        exx
ATT_BUF4
        exx
        INC HL
        INC HL
        exx
        ADD HL,DE
        DJNZ ATT_LP2
; 
; Un dernier passage pour passer les bons JUMP
; 
        ld HL,VROUT+1
        ld BC,VROUT_-VROUT-1
        exx
        pop HL
        ld DE,3
        ld A,(NBR_REG)
        ld B,A
ATT_LP3
        ld A,(HL)
        cp 1
        exx
        ld DE,DECOMP0
        JR Z,ATT_R1
        ld DE,DECOMP4
ATT_R1
        ld (HL),E
        INC HL
        ld (HL),D
        ADD HL,BC
        exx
        ADD HL,DE
        DJNZ ATT_LP3

; ------------------------
; CREEPLAY
; 
; Cree routine PLAYREG suivant taille des BUFFERS
; 
; ------------------------
        ld HL,OFBUF0
        ld DE,PLAYCODE
; 
        ld B,(HL)	; Poids fort du 1er tampon
        INC HL
        ld A,(HL)	; Taille
        INC HL
        cp 1
        call Z,CP_1
        call NZ,CP_4
; 
        ld B,13		; 13 premiers registre
CP_LP
        push BC
        call CP_COPY
; 
        ld B,(HL)
        INC HL
        ld A,(HL)
        cp 4
        call Z,CP_4
        JR Z,CP_SUI
; 
; on verifie si buffer precedent etait de taille 1,
; et s'il etait place cote @ cote, pour pouvoir mettre  INC L
; 
        dec HL
        dec HL
        cp (HL)
        call NZ,CP_1
        JR NZ,CP_SUI0
; 
        dec HL
        ld A,(HL)	; Adr precedente buffer
        INC HL
        SUB B
        INC A
        call Z,CP_1INC
        call NZ,CP_1
CP_SUI0
        INC HL
        INC HL
; 
CP_SUI
        INC HL
        pop BC
        DJNZ CP_LP
; 
; le registre 13 a un traitement different
; on le joue meme en cas de valeur identique, sauf si c'est &FF
; 
        ex DE,HL
        ld (HL),&7E             ; LD A,(HL)
        INC HL
        ld (HL),&3C             ; INC A
        INC HL
        ld (HL),&28             ; JR Z,
        INC HL
        ld (HL),MO_SAME-MO_SUITE+1
        INC HL
        ld (HL),&3D             ; DEC A
        INC HL
        ex DE,HL
; 
        ld HL,MO_SUITE
        ld BC,MO_END-MO_SUITE
        ldir
; 
        dec DE          ; On ecrase dernier INC C
        ld HL,MO2
        ld BC,MO2_END-MO2
        ldir

; POKECODE
; 
; Code bon nombre de LDIs dans routines de decompression
; 
; ------------------------
; RAZVAR
; 
; Toutes les auto-modifs pour la gestion
; 
; ------------------------
        ld HL,VMESURE
        ld (GETWITCH+1),HL

;        IF WANTLOOP
        ld HL,V0
        ld (GETWITC_+1),HL
        XOR A
        ld (DECALEH+1),A
;        END
        ld HL,0
        ld (PLAYPLAG+1),HL
; ------------------------
; 
; SETVAR
; 
; Init variables REGS pour la decompression.
; 
; ------------------------
        ld HL,OFBUF0
        exx
        ld A,(NBR_REG)
        ld B,A          ; Nombre registres traites
        ld DE,(ADRTEMP) ; Pointe sur donnees (en relatif)
        INC DE
        INC DE          ; Saute "longueur"
        ld HL,REGS
RAZLOOP
        push BC
; 
; On place adr DEST
; 
        EXX
        ld A,(HL)
        INC HL
        INC HL
        EXX
        ld (HL),0
        INC HL
        ld (HL),A
        INC HL
; 
; Adr source pour copie chaine forcement meme poids fort qd fenetre &100
; 
        INC HL
        ld (HL),A
        INC HL
; 
; Valeur decalage (quand boucle, les donnees ne sont plus placees a partir de 0,
; les references absolues doivent etre corrigees)
; 
        ld (HL),0
        INC HL
; 
; On place nbr de chr restant a copier = 0
; 
        ld (HL),0
        INC HL
; 
; Octet flag a &40 pour copie 1er octet et enclencher lecture nouveaux flags
; 
        ld (HL),&40
        INC HL
        INC HL
; 
; Maintenant il faut lire adr debut donnees compresses,
; donnees en relatif par rapport a position courante dans header
; 
        ex DE,HL
        INC HL          ; On saute type compression
        ld C,(HL)
        INC HL
        ld B,(HL)
; 
        push HL
        ADD HL,BC
        ld B,H
        ld C,L
        pop HL
; 
        INC HL
        ex DE,HL
        ld (HL),C
        INC HL
        ld (HL),B
        INC HL

        pop BC
        DJNZ RAZLOOP
; 
        ld HL,REGS      ; On copie variable pour reset/bouclage
        ld DE,REGSCOPY
        ld BC,16*10
        ldir

; ------------------------
; RAZ_PSG
; 
; La routine de PLAY ne met pas a jour les registres s'ils ne sont pas modifies.
; Or, ils sont consideres a 0 lors de la 1er interation.
; On doit donc reelement les mettre a 0. (nb 7 a 0 canaux et bruit ouverts)
; 
; ------------------------
        ld bc,&0e0d     ; 14 number of loop 13 number of register minus one
        ld de,&f4c0
        ld l,&80
        xor a

Clear_PSG_Register_Loop
        ld h,b

; clear psg registers
        ld b,d          ; Port A &f4
        out (c),c       ; Select register
        inc b
        inc b           ; Port C &f6
        out (c),d       ; &c0 11000000 Select Reg AY
        defb &ED,&71    ; &00 00000000 Validation out (c),0  
        ld b,d          ; Port A &f4
        out (c),a
        inc b
        inc b           ; &f6
        out (c),l       ; &80 10000000 Write data
        defb &ED,&71    ; &00 00000000 Validation out (c),0

        ld b,h

        dec c           ; next reg
        djnz Clear_PSG_Register_Loop

; ------------------------
; 
; Il faut preparer quelques donnees d'avances
; 
; ------------------------
        ld A,(NBR_REG)
AMORCE
        push AF
        call GETREG
        pop AF
        dec A
        JR NZ,AMORCE
        ret

;        IF WANTLOOP
;        ELSE
;MESURE
;	ld HL,0
;        dec HL
;        ld (MESURE+1),HL
;        ld A,H
;        OR L
;        JR Z,FIN
;        END
;        ret

MODELE
        ld A,(HL)
        CP 0
        JR Z,MO_SAME
        ld (0),A	; 0 remplace dans CREEPLAY
MO_SUITE
        out (C),C	; Registre
        exx
        defb &ED,&71	;  OUT (C),0
        ld B,H
        out (C),A
        ld B,L
        out (C),E
        out (C),D
        exx
MO_SAME
        INC C
MO_END

MO2
        INC DE
        ld A,D
        AND &3
        ld D,A
        ld (PLAYPLAG+1),DE
        ret
MO2_END

PLAYREG
        ld DE,&C080
        ld HL,&F4F6
        ld B,L
        out (C),D
        exx
PLAYPLAG
        ld DE,0		; Fourni poids faible (sur 8 et 10 bits)
;  PLAYPLAG est remis a jour la fin
        ld L,E
        ld B,&F4
        ld C,0

; Partie  cree par CREEPLAY

PLAYCODE        defs MO_END-MODELE+4*14,0
                defs MO2_END-MO2,0

; ------------------------
GETREG
; ------------------------
        ld (SAVETMP+1),SP
        ld A,(NBR_REG)		; Necessaire pour V1 a V13
        dec A			; mais pas pour VMESURE/V0
;        IF WANTLOOP
        defb &DD
DECALEH ld H,0
;        END
        ld IY,GET_RET
GETWITCH
        JP V0			; Quelle routine ?
GET_RET
        ld HL,(GETWITCH+1)
        dec HL
        ld D,(HL); Recupere adresse
        dec HL
        ld E,(HL)
        ld (GETWITCH+1),DE
SAVETMP	ld SP,0
	ret

        defw V1		; Adresse prochaine routine
VMESURE
;        IF WANTLOOP

; S'il reste moins que "NBR_REG" donnees a recuperer,
; on recupere ces quelques donnees, on reset (methode brute pour l'instant),
; puis on recupere qq donnees complementaire.
; 
; Sinon, on saute normallement a V0, et le test ne sera pas effectue
; de V1 a V13 ...
; 
MESURE  ld HL,0
        ld C,L
        ld D,0
        ld A,(NBR_REG)
        ld E,A
        OR A
        SBC HL,DE
        ld (MESURE+1),HL
        dec A
	jp nc,V0
; 
; Pour V1 etc..., on ne refera pas le test precedent
; 
        ld B,D
        ld DE,RETIENT
        ld (GETWITCH+1),DE
        ld DE,(MUSIC_ADDRESS)
        ADD HL,DE
        ld (MESURE+1),HL
        ld A,C
        ld (COMPLETE+1),A
        ld (RETIENT+1),A
; 
; On doit determiner la position destination dans les buffers
; 
        ld HL,(PLAYPLAG+1)
        ADD HL,BC
        ld A,(NBR_REG)
        ld C,A
        ADD HL,BC
        ld A,H
        AND &3
        ld (DECALEH+1),A
        ld A,L
        ld (DECALEL+1),A
; 
RETIENT ld A,0
        dec A
	jp m,CAS0		; 0 data ? Il faut reseter
        ld IY,GET_RET_
GETWITC_
	JP V0
; 
CAS0
        ld A,(NBR_REG)
        JR RESET
; 
GET_RET_
        ld A,(NBR_REG)
COMPLETE
        ld B,0
        SUB B
; 
RESET
        ld HL,(GETWITC_+1)
        INC HL
        ld E,(HL)		; Plage de variable
        INC HL
        ld D,(HL)
        INC DE
        INC DE
        INC DE
        INC DE
        ld HL,REGSCOPY-REGS+1
        ADD HL,DE
        ex DE,HL
DECALEL ld (HL),0
        INC HL
        ex DE,HL
        LDI
        LDI
        LDI
        LDI
        LDI
; 
        ld IY,GET_RET2
        dec A
        JR GETWITC_
GET_RET2
        ld HL,(GETWITC_+1)
        dec HL
        ld D,(HL)		; Recupere adresse
        dec HL
        ld E,(HL)
        ld HL,-VMESURE-1	; Pour redirection, il faut boucler sur 
        ADD HL,DE		; V0
        JR C,REGLP_OK
        ld HL,VMESURE
        ld (GETWITCH+1),DE
        ld DE,V0
REGLP_OK
        ld (GETWITC_+1),DE
        ld SP,(SAVETMP+1)
        ret
; 
; 
; 
	defw V1
;        END
V0
        ld SP,REGS		; !!! PLACER le LD SP apres le label !!!
VROUT	jp DECOMP4		; ATTENTION ! L'ecart doit rester
	defw V2
V1
	ld SP,REGS+10
VROUT_	jp DECOMP0		; constant pour les modifs d'ATTRIBU
	defw V3
V2
        ld SP,REGS+20
        JP DECOMP4
	defw V4
V3
        ld SP,REGS+30
        JP DECOMP0
	defw V5
V4
	ld SP,REGS+40
        JP DECOMP4
	defw V6
V5
        ld SP,REGS+50
        JP DECOMP0
	defw V7
V6
        ld SP,REGS+60
        JP DECOMP0
	defw V8
V7
        ld SP,REGS+70
        jp DECOMP0
	defw V9
V8
        ld SP,REGS+80
        JP DECOMP0
	defw V10
V9
        ld SP,REGS+90
        JP DECOMP0
	defw V11
V10
        ld SP,REGS+100
        JP DECOMP0
	defw V12
V11
        ld SP,REGS+110
        JP DECOMP0
	defw V13
V12
        ld SP,REGS+120
        JP DECOMP0
	defw VMESURE		; !!! BOUCLE EN CONCORDANCE AVEC NBR_REG
V13
        ld SP,REGS+130
        JP DECOMP0
	defw V15
V14
        ld SP,REGS+140
        JP DECOMP0
	defw V0
V15
        ld SP,REGS+150
	JP DECOMP0
; 
; 
D0_CHR
; 
; Place  en premier pour etre atteint par JR
; 
        ex AF,AF'
        ld A,(HL)
        INC HL
        exx
        ld (DE),A
        INC E
        ex AF,AF'
; 
; On decremente nbr de caracteres restants.
; 
        dec A
        EXX
        JP P,D0_NEXT
; 
; 
        push HL
        push BC
        EXX
; 
        push BC		; B DOIT ETRE NUL ICI
        push HL		; Bidon
        push DE
        JP (IY)

DECOMP0

; Entree  A  = nbr de donnees a decompacter - 1
;         IY = adr de retour
; On suppose que longueur est code en negatif (ie -2 -> 2 caracteres)
; 
; On recupere adr destination dans tous les cas
; (Remarque D ne change pas, il y a peut etre moyen d'optimiser cela)
; 
        pop DE
        pop HL		; Adresse source pour copie chaine
; 
; On recupere B = nbr de caracteres a copier   C est inutilise
; 
        pop BC
        INC B
        dec B
        JR Z,D0_FLAG

D0_MESUR

; On regarde si longueur de chaine restante > nbr de donnees a fournir
; 
;        IF WANTLOOP
        EXX
        ld D,A
        EXX
        ADD A,B		; longueur codee en negatif
        JR NC,D0_AL_
;        ELSE
;        ADD A,B
;        JR NC,D0_ALL
;        END

        ex AF,AF'
D0_LP1
        ld A,(HL)
        INC L
        ld (DE),A
        INC E
        INC B
        JR NZ,D0_LP1
        ex AF,AF'
D0_FLAG

; On recupere FLAGs et pointeur donnees compressees
; (B inutilise)

        EXX
        pop BC
        pop HL

; On extrait nouveau flag

D0_NEXT
        SLA C
        JR NZ,D0_FLGOK

        ld C,(HL)
        INC HL
	defb &CB,&31 	; SLL C
D0_FLGOK
        JR NC,D0_CHR

; Test similaire au precedent

        ld B,(HL)
        INC HL
        ld D,A		; Sauve pour D0_LEFT
        ADD A,B
        JR NC,D0_LEFT
; 
; Il restera (A+1) donnees a fournir apres copie de la chaine
; 
        ex AF,AF'
        ld A,B
        exx
        ld B,A
        exx
        ld A,(HL)
        INC HL
        exx
;        IF WANTLOOP
        ADD A,C
;        END
        ld L,A
D0_LP2
        ld A,(HL)
        INC L
        ld (DE),A
        INC E
        INC B
        JR NZ,D0_LP2
        ex AF,AF'
        exx
        JR D0_NEXT

D0_LEFT

; Idem que D0_ALL mais sur moins de donnees.

        ex AF,AF'	; Pour l'instant on conserve A-B
        ld A,D		; Nombre de valeur restantes a copier-1
        exx
        ld B,A
        INC B
        exx
        ld A,(HL)
        INC HL
        push HL
        push BC
        exx
;        IF WANTLOOP
        ADD A,C
;        END
        ld L,A
D0_LP3
        ld A,(HL)
        INC L
        ld (DE),A
        INC E
        DJNZ D0_LP3
        ex AF,AF'
        ld B,A
        INC B		; Longueur restante pour prochaine fois
        push BC

        push HL
        push DE
        jp (IY)

;        IF WANTLOOP
D0_AL_

;   D0_ALL ne convient pas quand on veut changer dynamiquement le nombre
;   de valeurs a recuperer (c'est le cas pour le bouclage).

        INC A
        ld B,A
        push BC
        exx
        ld A,D
        exx
        ld B,A
        INC B
; 
D0_AL_LP
        ld A,(HL)
        ld (DE),A
        INC L
        INC E
        DJNZ D0_AL_LP

	push HL
	push DE
	jp (IY)

;        ELSE
; 
;D0_ALL
; 
; La chaine a copier fournie toutes les donnees
; 
;        INC A
;        ld B,A		; Longueur restante pour prochaine fois
;        push BC
; 
;D0_COPY
;        ld A,(HL)
;        ld (DE),A
;        INC L
;        INC E
;        DEFS 80,0		; Place pour NBR_REG copies
;        DEFS 5,0		; Place pour D0_MODEL
; 
;D0_MODEL; Sera copie a la suite des LDI
;        push HL
;        push DE
;        jp (IY)
;D0_MODE_
; 
;        END


D4_CHR

; Place  en premier pour etre atteint par JR
; 
        ex AF,AF'
        ld A,(HL)
        INC HL
        exx
        ld (DE),A
        INC DE
        res 2,D
        ex AF,AF'
; 
; On decremente nbr de caracteres restants.
; 
        dec A
        exx
	jp p,D4_NEXT

	push HL
        push BC
        exx
; 
        push BC		; B DOIT ETRE NUL ICI
        push HL		; Bidon
        push DE
        jp (IY)
; Base sur DECOMP0
; Entree  A  = nbr de donnees a decompacter - 1
;         IY = adr de retour
; On suppose que longueur est code en negatif (ie -2 -> 2 caracteres)
; 
; On recupere adr destination dans tous les cas
; (Remarque D ne change pas, il y a peut etre moyen d'optimiser cela)
; 
DECOMP4
        pop DE
        pop HL		; Adresse source pour copie chaine
; 
; On recupere B = nbr de caracteres a copier   C est inutilise
; 
        pop BC
        INC B
        dec B
        JR Z,D4_FLAG
; 
D4_MESUR
; 
; On regarde si longueur de chaine restante > nbr de donnees a fournir
; 
;        IF WANTLOOP
        exx
        ld D,A
        exx
        ADD A,B		; longueur codee en negatif
        JR NC,D4_AL_
;        ELSE
;        ADD A,B
;        JR NC,D4_ALL
;        END
; 
        ex AF,AF'
D4_LP1
        ld A,(HL)
        INC HL
        res 2,H
        ld (DE),A
        INC DE
        res 2,D
        INC B
        JR NZ,D4_LP1
        ex AF,AF'
 
D4_FLAG
 
; On recupere FLAGs et pointeur donnees compressees
; (B inutilise)

        exx
        pop BC
        pop HL


; On extrait nouveau flag

D4_NEXT
        sla C
        JR NZ,D4_FLGOK

        ld C,(HL)
        INC HL
        defb &CB,&31	; SLL C
D4_FLGOK
        JR NC,D4_CHR
; 
; Test similaire au precedent
; 
        ld B,(HL)
        INC HL
        ld D,A		; Sauve pour D4_LEFT
        ADD A,B
        JR NC,D4_LEFT
; 
; Il restera (A+1) donnees a fournir apres copie de la chaine
; 
        ex AF,AF'
        ld A,B
        exx
        ld B,A
        exx
        ld A,(HL)
        INC HL
        exx
;        IF WANTLOOP
        ADD A,C
        ld L,A
        ld A,D
        res 0,A
        res 1,A
        exx
        adc A,(HL)
        defb &DD
        ADD A,H
        AND &FB
;        ELSE
;        ld L,A
;        ld A,D
;        AND &FC
;        exx
;        OR (HL)
;        END
        INC HL
        exx
        ld H,A
D4_LP2
        ld A,(HL)
        INC HL
        res 2,H
        ld (DE),A
        INC DE
        res 2,D
        INC B
        JR NZ,D4_LP2
        ex AF,AF'
        exx
        JR D4_NEXT
; 
D4_LEFT
; 
; Idem que D4_ALL mais sur moins de donnees.
; 
        ex AF,AF'	; Pour l'instant on conserve A-B
        ld A,D		; Nombre de valeur restantes a copier-1
        EXX
        ld B,A
        INC B
        EXX
        ld A,(HL)
        INC HL
        EXX
;        IF WANTLOOP
        ADD A,C
        ld L,A
        ld A,D
        res 0,A
        res 1,A
        EXX
        ADC A,(HL)
        defb &DD
        ADD A,H
        AND &FB
;        ELSE
;        ld L,A
;        ld A,D
;        AND &FC
;        exx
;        OR (HL)
;        END
        INC HL
        push HL
        push BC
        EXX
        ld H,A
D4_LP3
        ld A,(HL)
        INC HL
        res 2,H
        ld (DE),A
        INC DE
        res 2,D
        DJNZ D4_LP3
        ex AF,AF'
        ld B,A
        INC B		; Longueur restante pour prochaine fois
        push BC
; 
        push HL
        push DE
        jp (IY)

;        IF WANTLOOP
D4_AL_

;   D0_ALL ne convient pas quand on veut changer dynamiquement le nombre
;   de valeurs a recuperer (c'est le cas pour le bouclage).

        INC A
        ld B,A
        push BC
        exx
        ld A,D
        exx
        ld B,A
        INC B

D4_AL_LP
        ld A,(HL)
        ld (DE),A
        INC HL
        res 2,H
        INC DE
        res 2,D
        DJNZ D4_AL_LP

        push HL
        push DE
        jp (IY)

;	ELSE

;D4_ALL

; La chaine a copier fournie toutes les donnees

;        INC A
;        ld B,A			; Longueur restante pour prochaine fois
;        push BC

;D4_COPY
;        ld A,(HL)
;        ld (DE),A
;        INC HL
;        res 2,H
;        INC DE
;        res 2,D
;        DEFS 154,0		; Place pour NBR_REG copies
;        DEFS 5,0		; Place pour D0_MODEL

;D4_MODEL			; Sera copie a la suite des LDI
;        push HL
;        push DE
;        jp (IY)
;D4_MODE_

;        END


 
CP_COPY

; On copie partie OUTs

        push HL
        ld HL,MODELE
        LDI		; LD A,(HL)
        LDI		; CP 0
        ld B,D		; on stocke nn...
        ld C,&FF	; Pour que LDI ne modifisse pas B !
        ld A,E
        LDI
        LDI		; JR Z,MO_SAME
        LDI
        LDI		; LD (nn),A
        ld (DE),A	; ...et ici on copie nn !
        INC DE
        ld A,B
        ld (DE),A
        INC DE

CP_COPY2
        ld HL,MO_SUITE
        ld BC,MO_END-MO_SUITE
        ldir
        pop HL
        ret
CP_1

; Si tampon de taille &100 on code
;     LD   H,n
; 
        ex DE,HL
        ld (HL),&26
        INC HL
        ld (HL),B
        INC HL
        ex DE,HL
        ret
; 
; 
CP_1INC
; 
; Quand 2 tampon de taille &100 successif, on code
;     INC  H
; 
        ld A,&24
        ld (DE),A
        INC DE
        ret
; 
; 
CP_4
; 
; Si c'est un tampon de taille &400, on code
;      LD   A,n
;      OR   D
;      LD   H,A
; 
        ex DE,HL
        ld (HL),&3E
        INC HL
        ld (HL),B
        INC HL
        ld (HL),&B2
        INC HL
        ld (HL),&67
        INC HL
        ex DE,HL
        ret

VAR		; Variables de travail

REGS		DEFS 16*10,0 ; Variables pour chaque registre
REGSCOPY	DEFS 16*10,0 ; Pour reset lors du bouclage

;  Pour chaque registre, on a :

;  Adresse destination     (DE)
;  Adresse source chaine   (HL)  ne sert pas forcement
;  Flag/compteur chaine    (BC)  C : poids faible decalage
;  Octet flags             (BC') B' inutilise
;  Source data compresses  (HL')

; DATA

; NBR_REG est une constante qui permet de determiner combien recuperer
; de donnees a la fois. Si NBR_REG = 14, on recupere 14 donnees par registre et
; par VBL. Au bout de 14 VBL, on peut jouer 14 fois tous les reg., le temps de
; recuperer 14*14 nouvelles donnees.

NBR_REG		defb 14			; !!! MODIFIER (V14-2) EN CONSEQUENCE !!
ADRTEMP		defw MUSIC_ADDRESS
OFBUF0		defb BUFFER_ADDRESS	; Poids fort adresse
		defb 1 			; Taille (1 ou 4) pour CREEPLAY 

; Attention les tampons de &400 doivent commencer en &x000 ou &x800

defb BUFFER_ADDRESS+01,1,BUFFER_ADDRESS+02,1,BUFFER_ADDRESS+03,1,BUFFER_ADDRESS+04,1
defb BUFFER_ADDRESS+05,1,BUFFER_ADDRESS+06,1,BUFFER_ADDRESS+07,1,BUFFER_ADDRESS+08,1
defb BUFFER_ADDRESS+09,1,BUFFER_ADDRESS+10,1,BUFFER_ADDRESS+11,1,BUFFER_ADDRESS+12,1
defb BUFFER_ADDRESS+13,1,BUFFER_ADDRESS+14,1,BUFFER_ADDRESS+15,1

list
; end of file
EOF_ADDRESS
EOF_LENGTH equ EOF_ADDRESS-&4000
